package amtf

import (
	"fmt"
	"strings"

	"server/global"
	"server/model/common/response"
	"server/utils"

	"github.com/gin-gonic/gin"
	"go.uber.org/zap"
)

var Aapi = new(Sapi)

type Sapi struct {
	A组件 *S组件 `json:"-"`
}

func (a *Sapi) A增(c *gin.Context) {
	// var model = a.A组件.Amodel
	model, _, service := A解构组件(a.A组件)
	// model = A实例转指针(model)
	err := c.ShouldBindJSON(model)
	if err != nil {
		response.FailWithMessage(err.Error(), c)
		return
	}
	记录id否(c, model)
	err = service.A增(model)

	组件名 := a.A组件.Name
	// msg := fmt.Sprintf("新增 %s 成功!", 组件名)
	if err != nil {
		msg := fmt.Sprintf("新增 %s 失败!", 组件名)
		global.GVA_LOG.Error(msg, zap.Error(err))
		response.FailWithMessage(msg+err.Error(), c)
		return
	}

	// response.OkWithMessage(msg, c)
	response.OkWithData(model, c)
}

func (a *Sapi) A删(c *gin.Context) {
	_, models, service := A解构组件(a.A组件)
	// model = A实例转指针(model)

	var ids []string
	id := c.Query("id")
	if id != "" {
		ids = append(ids, id)
		// fmt.Printf("删除一个 ids 👉 %+v\n", ids)
	} else {
		ids = c.QueryArray("ids[]")
		// fmt.Printf("删除多个 ids 👉 %+v\n", ids)
	}
	err := service.A删(ids, models)
	if err != nil {
		global.GVA_LOG.Error("删除失败!", zap.Error(err))
		response.FailWithMessage("删除失败:"+err.Error(), c)
		return
	}
	response.OkWithMessage("删除成功", c)
}

func (a *Sapi) A改(c *gin.Context) {
	model, models, service := A解构组件(a.A组件)
	if 是查设置否(c) {
		err := c.ShouldBindJSON(&models)
		if err != nil {
			response.FailWithMessage(err.Error(), c)
			return
		}
		fmt.Printf("models 👉 %+v\n", models)
		fmt.Printf("设置改 ing👇\n")
		err = service.A改多个(models)
		if err != nil {
			global.GVA_LOG.Error("更新失败!", zap.Error(err))
			response.FailWithMessage("更新失败:"+err.Error(), c)
			return
		}
	} else {
		err := c.ShouldBindJSON(&model)
		if err != nil {
			response.FailWithMessage(err.Error(), c)
			return
		}
		err = service.A改(model)
		if err != nil {
			global.GVA_LOG.Error("更新失败!", zap.Error(err))
			response.FailWithMessage("更新失败:"+err.Error(), c)
			return
		}
	}
	response.OkWithMessage("更新成功", c)
}

func (a *Sapi) A查(c *gin.Context) {
	_, _, service := A解构组件(a.A组件)
	id := c.Query("id")
	if id != "" {
		res, err := service.A查单个(id)
		if 查询正常否(c, err) {
			response.OkWithData(res, c)
		}
		return
	}

	// 查多个👇
	if 是查设置否(c) {
		list, total, err := service.A查设置()
		if 查询正常否(c, err) {
			result := map[string]any{
				"list":  list,
				"total": total,
			}
			response.OkWithDetailed(result, "获取成功", c)
		}
	} else {
		// a.A组件 := a.A组件
		var req = a.A组件.A列表req
		// var req ASearch
		err := c.ShouldBindQuery(&req)
		if err != nil {
			response.FailWithMessage(err.Error(), c)
			return
		}

		if err = 仅自己观(c, &req); err != nil {
			response.FailWithMessage(err.Error(), c)
		} else {
			list, total, err := service.A查(req)
			if 查询正常否(c, err) {
				response.OkWithDetailed(response.PageResult{
					List:     list,
					Total:    total,
					Page:     req.Page,
					PageSize: req.PageSize,
				}, "获取成功", c)
			}
		}
	}
}

func (a *Sapi) A查字段值选项集(c *gin.Context) {
	_, _, service := A解构组件(a.A组件)
	res, _ := service.A成字段值选项集()
	response.OkWithData(res, c)
}

// func (a *Sapi) GetAPublic(c *gin.Context) {
// 	// 此接口不需要鉴权 示例为返回了一个固定的消息接口，一般本接口用于C端服务，需要自己实现业务逻辑
// 	Aservice.GetAPublic()
// 	response.OkWithDetailed(gin.H{"model": "不需要鉴权的接口信息"}, "获取成功", c)
// }

func 是查设置否(c *gin.Context) (是否 bool) {
	是否 = strings.Contains(c.FullPath(), "/shezhi")
	return
}

func 仅自己观(c *gin.Context, req *S列表req) (err error) {
	if req.A仅自己 {
		id, err := utils.A取用户id(c)
		req.A用户id = fmt.Sprintf("%d", id)
		return err
	}
	return
}

func 记录id否(c *gin.Context, model any) bool {
	if !A有字段否(model, "A用户id") {
		return false
	}
	// A取字段反射值(model, "A用户id")
	userID := utils.GetUserID(c)
	A予字段值(model, "A用户id", userID)
	return true
}

func 查询正常否(c *gin.Context, err error) bool {
	message := "查询出错"
	return 正常否(c, err, message)
}

func 正常否(c *gin.Context, err error, message string) bool {
	if err != nil {
		global.GVA_LOG.Error(message, zap.Error(err))
		response.FailWithMessage(message+":"+err.Error(), c)
		return false
	}
	return true
}
